﻿namespace WMS6.Web.OutboundServiceRef
{
    using System;
    using System.CodeDom.Compiler;
    using System.Collections.Generic;
    using System.Data;
    using System.Diagnostics;
    using System.ServiceModel;
    using System.ServiceModel.Channels;

    [GeneratedCode("System.ServiceModel", "3.0.0.0"), DebuggerStepThrough]
    public class OutboundServiceClient : ClientBase<IOutboundService>, IOutboundService
    {
        public OutboundServiceClient()
        {
        }

        public OutboundServiceClient(string endpointConfigurationName) : base(endpointConfigurationName)
        {
        }

        public OutboundServiceClient(Binding binding, EndpointAddress remoteAddress) : base(binding, remoteAddress)
        {
        }

        public OutboundServiceClient(string endpointConfigurationName, EndpointAddress remoteAddress) : base(endpointConfigurationName, remoteAddress)
        {
        }

        public OutboundServiceClient(string endpointConfigurationName, string remoteAddress) : base(endpointConfigurationName, remoteAddress)
        {
        }

        public string AutoAllocate(List<string> orderIDS, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.AutoAllocate(orderIDS, updatedBy, pubParasInfo);
        }

        public string AutoPreAllocate(string orderID, string updateBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.AutoPreAllocate(orderID, updateBy, pubParasInfo);
        }

        public string AutoRevertAllocate(string orderID, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.AutoRevertAllocate(orderID, updatedBy, pubParasInfo);
        }

        public string AutoRevertPreAllocate(string orderID, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.AutoRevertPreAllocate(orderID, updatedBy, pubParasInfo);
        }

        public string BatchAllocate(string orderID, List<string> orderLineIDS, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.BatchAllocate(orderID, orderLineIDS, updatedBy, pubParasInfo);
        }

        public string BatchClosed(List<string> waveID, PubParasInfo pubParasInfo)
        {
            return base.Channel.BatchClosed(waveID, pubParasInfo);
        }

        public void BatchConfirmPicked(string waveID, PubParasInfo pubParasInfo)
        {
            base.Channel.BatchConfirmPicked(waveID, pubParasInfo);
        }

        public string BatchOrderActions(string batchOrderID, string batchOrderType, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.BatchOrderActions(batchOrderID, batchOrderType, updatedBy, pubParasInfo);
        }

        public string BatchPreAllocate(string orderID, List<string> orderLineIDs, string updateBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.BatchPreAllocate(orderID, orderLineIDs, updateBy, pubParasInfo);
        }

        public void BatchShipping(string waveID, PubParasInfo pubParasInfo)
        {
            base.Channel.BatchShipping(waveID, pubParasInfo);
        }

        public string CancelShipping(List<string> pickDetailID, PubParasInfo pubParasInfo)
        {
            return base.Channel.CancelShipping(pickDetailID, pubParasInfo);
        }

        public string CancelShippingByOrderID(List<string> orderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.CancelShippingByOrderID(orderID, pubParasInfo);
        }

        public string CancelShippingByOrderIDOrderLineID(string orderID, List<string> LineID, PubParasInfo pubParasInfo)
        {
            return base.Channel.CancelShippingByOrderIDOrderLineID(orderID, LineID, pubParasInfo);
        }

        public string CheckExternalIDExist(string externalID, PubParasInfo pubParasInfo)
        {
            return base.Channel.CheckExternalIDExist(externalID, pubParasInfo);
        }

        public List<InvLotLocLpnInfo> CheckLocationQty4Allocation(ManualAllocateParams manualAllocateParams, PubParasInfo pubParasInfo)
        {
            return base.Channel.CheckLocationQty4Allocation(manualAllocateParams, pubParasInfo);
        }

        public string CheckSkuIDExist(string orderID, string skuID, PubParasInfo pubParasInfo)
        {
            return base.Channel.CheckSkuIDExist(orderID, skuID, pubParasInfo);
        }

        public string ClosedByOrderID(List<string> orderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.ClosedByOrderID(orderID, pubParasInfo);
        }

        public string ConfirmPicked(List<string> pickDetailID, List<string> toLoc, string updateBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.ConfirmPicked(pickDetailID, toLoc, updateBy, pubParasInfo);
        }

        public string ConfirmShipped(List<string> pickDetailID, string updateBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.ConfirmShipped(pickDetailID, updateBy, pubParasInfo);
        }

        public string CreateOwnerTransferbyOrderIdLineID(string orderID, List<string> lineID, PubParasInfo pubParasInfo)
        {
            return base.Channel.CreateOwnerTransferbyOrderIdLineID(orderID, lineID, pubParasInfo);
        }

        public string DeleteOrderDetail(List<string> orderIDs, List<string> lineIDs, PubParasInfo pubParasInfo)
        {
            return base.Channel.DeleteOrderDetail(orderIDs, lineIDs, pubParasInfo);
        }

        public string DeleteOrderSelectionInfos(List<string> orderSelectionID, PubParasInfo pubParasInfo)
        {
            return base.Channel.DeleteOrderSelectionInfos(orderSelectionID, pubParasInfo);
        }

        public string DeleteOrdersInfos(List<string> ordersID, PubParasInfo pubParasInfo)
        {
            return base.Channel.DeleteOrdersInfos(ordersID, pubParasInfo);
        }

        public string DeleteShipmentContainer(List<string> shipmentContainerID, PubParasInfo pubParasInfo)
        {
            return base.Channel.DeleteShipmentContainer(shipmentContainerID, pubParasInfo);
        }

        public string DeleteWave(List<string> IDS, PubParasInfo pubParasInfo)
        {
            return base.Channel.DeleteWave(IDS, pubParasInfo);
        }

        public string DirectAllocation(string orderID, List<string> orderLineIDS, PubParasInfo pubParasInfo)
        {
            return base.Channel.DirectAllocation(orderID, orderLineIDS, pubParasInfo);
        }

        public string EncaseNesting(string strFromContainerID, string strToContainerID, PubParasInfo pubParasInfo)
        {
            return base.Channel.EncaseNesting(strFromContainerID, strToContainerID, pubParasInfo);
        }

        public string ExecuteExploding(List<string> orderIDs, List<string> lineIDs, PubParasInfo pubParasInfo)
        {
            return base.Channel.ExecuteExploding(orderIDs, lineIDs, pubParasInfo);
        }

        public DataSet GetAllIntransit(PubParasInfo pubParasInfo)
        {
            return base.Channel.GetAllIntransit(pubParasInfo);
        }

        public DataSet GetIntransitByQueryEntity(IntransitQueryEntity intransitQuery, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetIntransitByQueryEntity(intransitQuery, pubParasInfo);
        }

        public IntransitInfo GetIntransitInfoByID(string IntransitID, string srcDbID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetIntransitInfoByID(IntransitID, srcDbID, pubParasInfo);
        }

        public string GetOrderIDsByWaveID(string waveID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrderIDsByWaveID(waveID, pubParasInfo);
        }

        public DataSet GetOrdersByOrderSelection(OrderSelectionInfo OrderSelection, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrdersByOrderSelection(OrderSelection, pubParasInfo);
        }

        public DataSet GetOrdersByQueryEntity(OrdersQueryEntity ordersQueryEntity, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrdersByQueryEntity(ordersQueryEntity, pubParasInfo);
        }

        public OrderSelectionInfo GetOrderSelectionByID(string OrderSelectionID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrderSelectionByID(OrderSelectionID, pubParasInfo);
        }

        public DataSet GetOrderSelectionByQueryEntity(OrderSelectionQueryEntity OrderSelectionQuery, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrderSelectionByQueryEntity(OrderSelectionQuery, pubParasInfo);
        }

        public OrdersInfo GetOrdersInfoAndDetailListByID(string ordersID, string ContainerID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrdersInfoAndDetailListByID(ordersID, ContainerID, pubParasInfo);
        }

        public OrdersInfo GetOrdersInfoByID(string orderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrdersInfoByID(orderID, pubParasInfo);
        }

        public OrdersInfo GetOrdersInfoByQueryEntity(OrderDetailQueryEntity orderDetailQueryEntity, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetOrdersInfoByQueryEntity(orderDetailQueryEntity, pubParasInfo);
        }

        public DataSet GetPickDetailInfoByQueryEntity(PickDetailQueryEntity pickDetailQueryEntity, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetPickDetailInfoByQueryEntity(pickDetailQueryEntity, pubParasInfo);
        }

        public ShipmentContainerInfo GetShipmentContainerByID(string shipmentcontainerID, string orderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetShipmentContainerByID(shipmentcontainerID, orderID, pubParasInfo);
        }

        public List<ShipmentContainerInfo> GetShipmentContainerByOrderID(string OrderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetShipmentContainerByOrderID(OrderID, pubParasInfo);
        }

        public OrderDetailInfo GetShippingOrderDetailByID(string OrderID, string LineID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetShippingOrderDetailByID(OrderID, LineID, pubParasInfo);
        }

        public OrdersInfo GetShippingWeightByOrderID(string orderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetShippingWeightByOrderID(orderID, pubParasInfo);
        }

        public WaveInfo GetWaveByID(string id, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetWaveByID(id, pubParasInfo);
        }

        public DataSet GetWaveByQueryList(WaveQueryEntity waveQuery, PubParasInfo pubParasInfo)
        {
            return base.Channel.GetWaveByQueryList(waveQuery, pubParasInfo);
        }

        public string InsertOrderDetailInfo(OrderDetailInfo ordersDetailInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.InsertOrderDetailInfo(ordersDetailInfo, pubParasInfo);
        }

        public string InsertOrderSelectionInfo(OrderSelectionInfo orderSelectionInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.InsertOrderSelectionInfo(orderSelectionInfo, pubParasInfo);
        }

        public string InsertOrdersInfo(OrdersInfo ordersInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.InsertOrdersInfo(ordersInfo, pubParasInfo);
        }

        public string InsertShipmentContainer(List<ShipmentContainerInfo> shipmentcontainerInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.InsertShipmentContainer(shipmentcontainerInfo, pubParasInfo);
        }

        public string InsertWave(WaveInfo obj, PubParasInfo pubParasInfo)
        {
            return base.Channel.InsertWave(obj, pubParasInfo);
        }

        public string ManualAllocate(List<PickDetailInfo> pickDetailInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.ManualAllocate(pickDetailInfo, pubParasInfo);
        }

        public string ReleasePcTasks(List<string> RequestID, string updateBy, string PcStatus, PubParasInfo pubParasInfo)
        {
            return base.Channel.ReleasePcTasks(RequestID, updateBy, PcStatus, pubParasInfo);
        }

        public string ReleasePickTasks(List<string> pickDetailID, string updateBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.ReleasePickTasks(pickDetailID, updateBy, pubParasInfo);
        }

        public string RevertAllocate(List<string> PickDetailIDs, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.RevertAllocate(PickDetailIDs, updatedBy, pubParasInfo);
        }

        public string RevertPicked(List<string> pickDetailID, string updateBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.RevertPicked(pickDetailID, updateBy, pubParasInfo);
        }

        public string RevertPickedAllocated(List<string> pickDetailID, PubParasInfo pubParasInfo)
        {
            return base.Channel.RevertPickedAllocated(pickDetailID, pubParasInfo);
        }

        public string RevertPreAllocate(string orderID, List<string> lineIDs, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.RevertPreAllocate(orderID, lineIDs, updatedBy, pubParasInfo);
        }

        public string ScanShipmentContainer(List<ShipmentContainerInfo> shipmentcontainerList, PubParasInfo pubParasInfo)
        {
            return base.Channel.ScanShipmentContainer(shipmentcontainerList, pubParasInfo);
        }

        public string ShippedByOrderID(List<string> orderID, string shippDate, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.ShippedByOrderID(orderID, shippDate, updatedBy, pubParasInfo);
        }

        public string ShippedByOrderLineID(string orderID, List<string> orderLineIDs, string shippDate, string updatedBy, PubParasInfo pubParasInfo)
        {
            return base.Channel.ShippedByOrderLineID(orderID, orderLineIDs, shippDate, updatedBy, pubParasInfo);
        }

        public string ShippingWeightCancelOrder(List<string> orderID, PubParasInfo pubParasInfo)
        {
            return base.Channel.ShippingWeightCancelOrder(orderID, pubParasInfo);
        }

        public string UpateActualShipDateByOrderID(string OrderID, string actualShipDate, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpateActualShipDateByOrderID(OrderID, actualShipDate, pubParasInfo);
        }

        public string UpateActualShipDateByOrderIDLineID(string OrderID, List<string> LineID, string actualShipDate, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpateActualShipDateByOrderIDLineID(OrderID, LineID, actualShipDate, pubParasInfo);
        }

        public string UpateActualShipDateByPickDetailID(List<string> pickDetailID, List<string> OrderID, List<string> LineID, string actualShipDate, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpateActualShipDateByPickDetailID(pickDetailID, OrderID, LineID, actualShipDate, pubParasInfo);
        }

        public string UpdateOrderDetailInfo(OrderDetailInfo ordersDetailInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateOrderDetailInfo(ordersDetailInfo, pubParasInfo);
        }

        public string UpdateOrdersByShippingWeight(OrdersInfo ordersInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateOrdersByShippingWeight(ordersInfo, pubParasInfo);
        }

        public string UpdateOrderSelectionInfo(OrderSelectionInfo orderSelectionInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateOrderSelectionInfo(orderSelectionInfo, pubParasInfo);
        }

        public string UpdateOrdersInfo(OrdersInfo ordersInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateOrdersInfo(ordersInfo, pubParasInfo);
        }

        public string UpdateOrdersIsCancel(string orderid, string isCancel, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateOrdersIsCancel(orderid, isCancel, pubParasInfo);
        }

        public string UpdateOrdersPackingType(List<string> orderID, string packingType, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateOrdersPackingType(orderID, packingType, pubParasInfo);
        }

        public string UpdateShipmentContainer(List<ShipmentContainerInfo> shipmentcontainerList, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateShipmentContainer(shipmentcontainerList, pubParasInfo);
        }

        public string UpdateShippUDFByOrderID(List<OrderDetailInfo> orderDetailInfo, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateShippUDFByOrderID(orderDetailInfo, pubParasInfo);
        }

        public string UpdateWave(WaveInfo obj, PubParasInfo pubParasInfo)
        {
            return base.Channel.UpdateWave(obj, pubParasInfo);
        }
    }
}

